package client;



import interfaz.InterfazAlumnos;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.Vector;
import bean.AlumnoVO;
import bean.CursoVO;
import bean.MateriaVO;
import bean.ProfesorVO;

public class BDelegate extends UnicastRemoteObject{

	private static final long serialVersionUID = 1L;
	private InterfazAlumnos modelo;
	
	public BDelegate() throws RemoteException {
		super();
		getConexion();
	}


	public void getConexion(){
		
		try {
			modelo = (InterfazAlumnos) Naming.lookup("//127.0.0.1/InterfazAlumnos");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public InterfazAlumnos getModelo(){
		
		return modelo;
		
	}
	
	//Materias
	
	public MateriaVO buscarMateria (MateriaVO mVO){
		MateriaVO salida = null;
		try {
			salida =   modelo.buscarMateria(mVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
	}
		
	public boolean existeMateria (MateriaVO mVO) {
		boolean salida = false;
		try {
			salida = modelo.existeMateria(mVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
	}
	
    public void actualizarMateria (MateriaVO mVO){
    	try {
			modelo.actualizarMateria(mVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
    
    public void guardarMateria (MateriaVO mVO){
    	try {
			modelo.guardarMateria(mVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
    
    public void eliminarMateria (MateriaVO mVO){
    	try {
			modelo.eliminarMateria(mVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
   
    
    public Vector <MateriaVO> obtenerMaterias(){
    	Vector <MateriaVO> salida = new Vector <MateriaVO>();
    	try {
			salida =  modelo.obtenerMaterias();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    //Alumnos
    
    public AlumnoVO buscarAlumno (AlumnoVO aVO){
    	AlumnoVO salida = null; 
    	try {
			salida =  modelo.buscarAlumno(aVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
	public boolean existeAlumno (AlumnoVO aVO){
		boolean salida = false;
		try {
			salida = modelo.existeAlumno(aVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
	}
	
    public void actualizarAlumno (AlumnoVO aVO){
    	try {
			modelo.actualizarAlumno(aVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
    
    public void guardarAlumno (AlumnoVO aVO){
    	try {
			modelo.guardarAlumno(aVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
    
    public void eliminarAlumno (AlumnoVO aVO){
    	try {
			modelo.eliminarAlumno(aVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
    
    
    public Vector <AlumnoVO> obtenerAlumnos(){
    	Vector <AlumnoVO> salida = new Vector <AlumnoVO>();
    	try {
			salida =  modelo.obtenerAlumnos();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    
    //Profesores
    
    public ProfesorVO buscarProfesor (ProfesorVO pVO){ 	
    	ProfesorVO salida = null ;
    	try {
			salida = modelo.buscarProfesor(pVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
	public boolean existeProfesor (ProfesorVO pVO){
		boolean salida = false;
		try {
			salida = modelo.existeProfesor(pVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
	}
	
    public void actualizarProfesor (ProfesorVO pVO){
    	try {
			modelo.actualizarProfesor(pVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
    
    public void guardarProfesor (ProfesorVO pVO){
    	try {
			modelo.guardarProfesor(pVO);
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
    
    public void eliminarProfesor (ProfesorVO pVO){
    	try {
			modelo.eliminarProfesor(pVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
    
    public Vector <ProfesorVO> obtenerProfesores(){
    	Vector <ProfesorVO> salida = new Vector <ProfesorVO>();
    	try {
			salida =  modelo.obtenerProfesores();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    
    
    //Cursos
    
    public CursoVO buscarCurso (CursoVO cVO){
    	CursoVO salida = null;
    	try {
			salida =  modelo.buscarCurso(cVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    public boolean existeCurso(MateriaVO mVO, ProfesorVO pVO){
    	boolean salida = false;
    	try {
			salida = modelo.existeCurso(mVO, pVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    public void actualizarCurso(CursoVO cVO){
    	try {
			modelo.actualizarCurso(cVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
    }
    
    public void guardarCurso(CursoVO cVO){
    	try {
			modelo.guardarCurso(cVO);
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	
    }
    
    public void eliminarCurso(CursoVO cVO){
    	try {
			modelo.eliminarCurso(cVO);
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
    
    public Vector <CursoVO> obtenerCursos(){
    	Vector <CursoVO> salida = new Vector <CursoVO>();
    	try {
			salida =  modelo.obtenerCursos();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    
    
    // Asignaciones
    
    public void asignarMateriaProfesor(MateriaVO mVO, ProfesorVO pVO){
    	
    	try {
			modelo.asignarMateriaProfesor(mVO, pVO);
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	
    }
    
    public void quitarMateriaProfesor(MateriaVO mVO, ProfesorVO pVO){
    	
    	try {
			modelo.quitarMateriaProfesor(mVO, pVO);
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	
    }
    
    public void asignarAlumnoCurso(CursoVO cVO, AlumnoVO aVO){
    	
    	try {
			modelo.asignarAlumnoCurso(cVO, aVO);
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	
    }
    
    public void quitarAlumnoCurso(CursoVO cVO, AlumnoVO aVO){
    	
    	try {
			modelo.quitarAlumnoCurso(cVO, aVO);
		} catch (RemoteException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	
    }
    
    
    //Comprobacion Asociaciones
    
    public boolean existeCursoConMateria(MateriaVO mVO){
    	boolean salida = false;
    	try {
			salida = modelo.existeCursoConMateria(mVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    public boolean existeProfesorConMateria(MateriaVO mVO){
    	boolean salida = false;
    	try {
			salida = modelo.existeProfesorConMateria(mVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    public boolean existeCursoConProfesor(ProfesorVO pVO){
    	boolean salida = false;
    	try {
			salida = modelo.existeCursoConProfesor(pVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
    
    public boolean existeCursoConAlumno(AlumnoVO aVO){
    	boolean salida = false;
    	try {
			salida = modelo.existeCursoConAlumno(aVO);
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		return salida;
    }
	
}
